package org.example;

import com.alibaba.fastjson.JSON;

import java.util.*;
import java.util.stream.Collectors;

/**
 * @author liukaihao
 * @date ${YEAR}/${MONTH}/${DAY}
 */
public class Main {
    public static void main(String[] args) {

        /***
         * order 订单状态 1：未支付 2：已支付 3：退款 4：取消
         */
        //创建两个订单详情的对象
        OrderItem orderItem1 = new OrderItem(1001,1,30);
        OrderItem orderItem2 = new OrderItem(1002,1,70);
        //两个订单详情放入到list中
        List<OrderItem> orderItemList1 = new ArrayList<>();
        orderItemList1.add(orderItem1);
        orderItemList1.add(orderItem2);
        //创建一个订单对象，状态为1
        Order order1 = new Order(1,"zhansan",1,orderItemList1);


        //创建两个订单详情的对象
        OrderItem orderItem3 = new OrderItem(1003,2,20);
        OrderItem orderItem4 = new OrderItem(1004,2,80);
        List<OrderItem> orderItemList2 = new ArrayList<>();
        //两个订单详情放入到list中
        orderItemList2.add(orderItem3);
        orderItemList2.add(orderItem4);
        //创建一个订单对象，状态为2
        Order order2 = new Order(2,"lisi",2,orderItemList2);


        //创建一个订单集合
        List<Order> orders = new ArrayList<>();
        orders.add(order1);
        orders.add(order2);

        System.out.println(JSON.toJSONString(orders));

        /*  System.out.println;
         */

        //4.使用Stream API从订单列表中筛选出状态为“已完成”的订单
        List<Order> li = orders.stream().filter(order -> order.getStatus()==2).collect(Collectors.toList());
        System.out.println("第4题："+JSON.toJSONString(li));




        //5.给定一个customerId，计算该客户所有订单的总价（即所有OrderItem的价格乘以数量之和）
        String comusterId = "zhansan";
        long total = 0;
        //10001
        for(Order order : orders){//闯刚 10001
            //不相等就执行
            if(comusterId.equals(order.getCustomerId())) {
                for (OrderItem item : order.getItems()) {
                    total += item.getPrice() * item.getQuantity();
                }
            }
        }
        System.out.println("第5题："+total);

        //第2中实现方法
        for(Order order : orders){//闯刚 10001
            //不相等就执行
            if(comusterId.equals(order.getCustomerId())) {
                total = order.getTotalPrice().longValue();
            }
        }
        System.out.println("第5题[第2种方法]："+total);


        //6：统计每个产品的订单数量;统计每个产品被订购的次数，
        // 并返回一个Map<ProductId{产品id}, Integer{产品数量}>
        Map<Integer,Integer> map = new HashMap<>();
        //第一次for 是循环订单
        for(Order order:orders){
            //需要订购的 status=2
            if(order.getStatus() == 2) {
                //循环订单详情
                for (OrderItem item : order.getItems()) {
                    //获取产品id
                    Integer productId = item.getProductId();
                    //获取map中产品的数量
                    Integer count = map.get(productId);

                    if (null == count) {
                        //如果map中产品为空，就设置1
                        map.put(productId, 1);
                    } else {
                        //如果map中产品有值，就把value+1
                        map.put(productId, count + 1);
                    }
                }
            }
        }
        System.out.println("第6题:"+JSON.toJSONString(map));


        //7 使用Stream API找到总价最高的订单，并返回该订单。
        Order order = orders.stream().max(Comparator.comparingDouble(Order::getTotalPrice)).orElse(null);
        System.out.println("第7题:"+JSON.toJSONString(order));

        //8: 将订单列表按照总价从高到低排序
        List<Order> orderList = orders.stream().sorted(Comparator.comparingDouble(Order::getTotalPrice).reversed()).collect(Collectors.toList());
        System.out.println("第8题:"+JSON.toJSONString(orderList));

        //9:过滤出所有单价在特定区间（如50元至100元之间）内的产品，并返回这些产品的ProductId
        //定义一个收集所有订单详情的列表
        List<OrderItem> orderItemList = new ArrayList<>();
        //forEach就是循环
        orders.stream().forEach(x -> {
            orderItemList.addAll(x.getItems());
        });
        //System.out.println("orderItem999888:"+JSON.toJSONString(orderItemList));

        //filter是过滤
        orderItemList.stream().filter(o->o.getPrice()>=50&&o.getPrice()<=100).forEach(orderItem -> {
            System.out.println("第9题:"+JSON.toJSONString(orderItem));
        });


        //10：统计订单的不同状态的数量，并返回一个Map<Status, Long>
        Map<Integer,Long> retMap = orders.stream().collect(Collectors.groupingBy(Order::getStatus,Collectors.counting()));
        System.out.println("第10题:"+JSON.toJSONString(retMap));

    }
}